| Paradigm(s) | Natural language, Scripting |
|---|---|
| Appeared in | 1993 |
| Developer | Apple Inc. |
| Stable release | 2.4.1 (October 12, 2011) |
| Typing discipline | weak, dynamic |
| Influenced by | Natural language, HyperCard |
| OS | System 7, Mac OS 8, Mac OS 9, Mac OS X |
| License | Apple EULA (parts available under APSL) |
| Usual filename extensions | .scpt .AppleScript |
| Website | http://developer.apple.com/applescript/ |
AppleScript is a scripting language created by Apple Inc. and built into Macintosh operating systems since System 7. The term "AppleScript" may refer to the scripting system itself, or to particular scripts that are written in the AppleScript language.
AppleScript is primarily an inter-application processing system, designed to exchange data between and control other applications in order to automate repetitive tasks. AppleScript has some limited processing abilities of its own – basic calculation abilities, and some more intricate text processing tools – and is extensible, allowing the addition of scripting additions which add new functions to the language itself. Mainly, however, AppleScript relies on the built-in functionality of other applications and processes to handle complex tasks.
AppleScript has some elements of object-oriented programming, particularly in the construction of script objects, and some Lisp-like natural language processing tendencies, but does not strictly conform to either category.
Contents |
The AppleScript project was an outgrowth of the (now discontinued) HyperCard project. HyperCard contained an English language-based scripting language called HyperTalk, which could be used to program a HyperCard stack. Apple engineers recognized that a similar scripting language could be designed to be used with any application, and the AppleScript project was born as part of System 7.
AppleScript was released in October 1993 as part of System 7.1.1 (System 7 Pro, the first major upgrade to System 7). QuarkXPress (ver. 3.2) was one of the first major software applications that supported AppleScript. This in turn led to AppleScript being widely adopted within the publishing and prepress world, often tying together complex workflows. This was a key factor in retaining the Macintosh's dominant position in publishing and prepress, even after QuarkXpress and other publishing applications were ported to Microsoft Windows.
After some uncertainty about the future of AppleScript on Apple's next generation OS, the move to Mac OS X (around 2002), and its Cocoa frameworks greatly increased the usefulness and flexibility of AppleScript. Cocoa applications allow application developers to implement basic scriptability for their apps with minimal effort, broadening the number of applications that are directly scriptable. At the same time, the shift to the Unix underpinnings and AppleScript's ability to run Unix commands directly allowed AppleScripts much greater control over the operating system itself. AppleScript Studio, released with Mac OS X 10.2 as part of Xcode, and later AppleScriptObjC framework, released in Mac OS X 10.6, allows users to build native Cocoa applications using AppleScript.
AppleScript is one component of Mac OS X Automation technologies, along with Services and Automator.
AppleScript was designed to be used as an accessible end-user scripting language, offering users an intelligent mechanism to control applications, and to access and modify data and documents. AppleScript can be used to create automated workflows which can reduce the time and repetitiveness of various tasks, minimize the opportunity for human error, provide consistent output, and facilitate a manageable production system. AppleScript uses Apple Events: a set of standardized data formats that the Macintosh operating system uses to send information to applications. Apple Events allow a script to work with multiple applications simultaneously, passing data between them so that complex tasks can be accomplished without human interaction. For example, an AppleScript to create a simple web gallery might do the following:
For the user, hundreds or thousands of steps in multiple applications have been reduced to the single act of running the script, and the task is accomplished in much less time and with no possibility of random human error. A large complex script could be developed to run only once, while other scripts are used again and again.
An application's AppleScript elements are visible in the application's Scripting Dictionary (distributed as part of the application), which can be viewed in any script editor. Elements are generally grouped into suites, according to loose functional relationships between them. There are two basic kinds of elements present in any suite: Classes and Commands. Classes are scriptable objects - for example, a text editing application will almost certainly have classes for Windows, Documents, and Texts - and these classes will have properties that can be changed (window size, document background color, text font size, etc.), and may contain other classes (a window will contain one or more documents, a document will contain text, a text object will contain paragraphs and words and characters). Commands, by contrast, are commands that can be given to scriptable objects. The general format for a block of AppleScript is to tell a scriptable object to run a command.
All scriptable applications share a few basic commands and objects (usually called the Standard Suite) - commands to open, close or save a file, to print something, to quit, to set data to variables - as well as a basic application object that gives the scriptable properties of the application itself. Many applications have numerous suites capable of performing any task the application itself can perform. In exceptional cases, applications may support plugins which include their own scripting dictionaries.
AppleScript was designed with the ability to build scripts intuitively by recording user actions. When the AppleScript Editor is open and the Record button clicked, any user actions on the computer - in any application that supports AppleEvents and AppleScript recording - are converted to their equivalent AppleScript commands and placed in the script editor window. The resulting script can be saved and re-run to duplicate the original actions, or modified to be more generally useful.
In AppleScript, the traditional Hello, world! program could be written in many of different forms:
display dialog "Hello, world!" -- a modal window with "Ok" and "Cancel" buttons (you can customize the buttons) -- or display alert "Hello, world!" -- a modal window with a single "Ok" button -- or say "Hello, world!" -- an audio message using a synthesized computer voice
AppleScript has several user interface options, including dialogs, alerts, and list of choices.
-- Dialog set dialogReply to display dialog ¬ "Dialog Text" default answer ¬ "Text Answer" hidden answer false ¬ buttons {"Skip", "Okay", "Cancel"} ¬ default button ¬ "Okay" cancel button ¬ "Skip" with title ¬ "Dialog Window Title" with icon note ¬ giving up after 20
--Choose from list set chosenListItem to choose from list {"A", "B", "3"} ¬ with title "List Title" ¬ with prompt "Prompt Text" ¬ default items "B" ¬ OK button name "Looks Good!" ¬ cancel button name "Nope, try again" ¬ multiple selections allowed false ¬ with empty selection allowed
--Alert set resultAlertReply to display alert ¬ "Alert Text" as warning ¬ buttons {"Skip", "Okay", "Cancel"} ¬ default button 2 ¬ cancel button 1 ¬ giving up after 2
Each user interaction method can return the values of buttons clicked, items chosen or text entered for further processing.
For example:
display alert "Hello, world!" buttons {"Rudely decline", "Happily accept"} set theAnswer to button returned of the result if theAnswer is "Happily accept" then beep 5 else say "Piffle!" end if
Whereas Apple Events are a way to send messages into applications, AppleScript is a particular language designed to send Apple Events. In keeping with the Mac OS tradition of ease-of-use, the AppleScript language is designed on the natural language metaphor, just as the graphical user interface is designed on the desktop metaphor. A well-written AppleScript should be clear enough to be read and understood by anyone, and easily edited. The language is based largely on HyperCard's HyperTalk language, extended to refer not only to the HyperCard world of cards and stacks, but also theoretically to any document. To this end, the AppleScript team introduced the AppleEvent Object Model (AEOM), which specifies the objects any particular application "knows".
The heart of the AppleScript language is the use of terms that act as nouns and verbs that can be combined. For example, rather than a different verb to print a page, document or range of pages (printPage, printDocument, printRange) AppleScript uses a single "print" verb which can be combined with an object, such as a page, a document or a range of pages.
print page 1 print document 2 print pages 1 thru 5 of document 2
Generally, AEOM defines a number of objects—like "document" or "paragraph"--and corresponding actions—like "cut" and "close". The system also defines ways to refer to properties of objects, so one can refer to the "third paragraph of the document 'Good Day'", or the "color of the last word of the front window". AEOM uses an application dictionary to associate the Apple Events with human-readable terms, allowing the translation back and forth between human-readable AppleScript and bytecode Apple Events. To discover what elements of a program are scriptable, dictionaries for supported applications may be viewed. (In the Xcode and Script Editor applications, this is under File → Open Dictionary.)
To designate which application is meant to be the target of such a message, AppleScript uses a "tell" construct:
tell application "Microsoft Word" quit end tell
Alternatively, the tell may be expressed in one line by using an infinitive:
tell application "Microsoft Word" to quit
For events in the "Core Suite" (activate, open, reopen, close, print, and quit), the application may be supplied as the direct object to transitive commands:
quit application "Microsoft Word"
The concept of an object hierarchy can be expressed using nested blocks:
tell application "QuarkXPress" tell document 1 tell page 2 tell text box 1 set word 5 to "Apple" end tell end tell end tell end tell
The concept of an object hierarchy can also be expressed using nested prepositional phrases:
pixel 7 of row 3 of TIFF image "my bitmap"
which in another programming language might be expressed as sequential method calls:
getTIFF("my bitmap").getPixel(3,7);
AppleScript includes syntax for ordinal counting, "the first paragraph", as well as cardinal, "paragraph one". Likewise, the numbers themselves can be referred to as text or numerically, "five", "fifth" and "5" are all supported, they are called synonyms. Also, to add to the English-likeness, the word "the" can legally be used anywhere in the script in order to enhance readability: it has no effect on the functionality of the script.
Script editors provide a unified programing environment for AppleScripts, including tools for composing, validating, compiling, running, and debugging scripts. They also provide mechanisms for opening and viewing AppleScript dictionaries from scriptable applications, saving scripts in a number of formats (compiled script files, application packages, script bundles, and plain text files), and usually provide features such as syntax highlighting and prewritten code snippets.
AppleScripts can be run from a script editor, but it is usually more convenient to run scripts directly, without opening a script editor application. There are a number of options for doing so:
Many Apple applications, some third party applications, and some add-ons provide their own script menus. These may be activated in different ways, but all function in essentially the same manner.
AppleScript has a number of built-in classes (or data types), though of course an application can and most likely will define extra data types for its own purposes. The basic data classes that should be universally recognized are as follows:
Many AppleScript processes are managed by blocks of code, where a block begins with a command command and ends with an end command statement: for instance:
| Looping | Conditionals | Application Targeting | Error Handling |
|---|---|---|---|
Repeat with i from 1 to 2000 -- commands to be repeated end repeat |
if x is greater than 3 then -- commands else -- other commands end if |
tell application "MyApp" -- commands for app end tell |
try -- commands to be tested on error -- error commands end try |
One important variation on this block structure is in the form of on - end ... blocks that are used to define handlers (function-like subroutines). Handlers begin with on functionName() and ending with end functionName, and are not executed as part of the normal script flow unless called from somewhere in the script.
| Function handler | Folder actions block | Run handler |
|---|---|---|
on myFunction(parameters...) -- subroutine commands end myfunction |
on adding folder items to thisFolder after receiving theseItems -- commands to apply to the folder or items end adding folder items to |
on run -- commands end run |
Handlers can also be defined using "to" in place of "on" and can be written to accept labeled parameters, not enclosed in parens.
| Handler with Labeled Parameters | Handler Using "to" and Labeled Parameters |
|---|---|
on rock around the clock display dialog (clock as string) end rock -- called with: rock around the current date |
to check for yourNumber from bottom thru top if bottom ≤ yourNumber and yourNumber ≤ top then display dialog "Congratulations! You scored." end if end check --called with: check for 8 from 7 thru 10 |
There are four types of predefined handlers in AppleScript - run, open, idle, and quit - each of which is created in the same way as the run handler shown above.
on open theItems repeat with thisItem in theItems tell application "Finder" to update thisItem end repeat end open
When a script containing an "open handler' is saved as an applet, the applet becomes a droplet. A droplet can be identified in the Finder by its icon, which includes an arrow, indicating items can be dropped onto the icon. The droplet's open hander is executed when files or folders are dropped onto droplet's icon. References to the items dropped on the droplet's icon are passed to the droplet's script as the parameter of the open handler. A droplet can also be launched the same way as an ordinary applet, executing its run handler.
on idle --code to execute when the script's execution has completed return 60 -- number of seconds to pause before executing idle handler again end idle
An idle handler can be used in applets or droplets saved as stay-open applets, and is useful for scripts that watch for particular data or events. The length of the idle time is one second by default, but can be changed by including a 'return x' statement at the end of the subroutine, where x is he number of seconds the system should wait before running the handler again.
on quit --commands to execute before the script quits continue quit -- required for the script to actually quit end quit
Script objects may be defined explicitly using the syntax:
script scriptName -- commands and handlers specific to the script end script
Script objects can use the same 'tell' structures that are used for application objects, and can be loaded from and saved to files. Runtime execution time can be reduced in some cases by using script objects.
set variable1 to 1 -- create an integer variable called variable1 set variable2 to "Hello" -- create a text variable called variable2 copy {17, "doubleday"} to variable3 -- create a list variable called variable3 set {variable4 , variable5} to variable3 -- copy the list items of variable3 into separate variables variable4 and variable5 set variable6 to script myScript -- set a variable to an instance of a script
Tell application "Finder" set x to my myHandler() -- or set x to myHandler() of me end tell on myHandler() --commands end myHandler
Using the same technique for scripting addition commands can reduce errors and improve performance.
tell application "Finder" set anyNumber to my (random number from 5 to 50) end tell
An important aspect of the AppleScript implementation is the Open Scripting Architecture (OSA).[2] Apple provides OSA for third-party scripting/automation products such as QuicKeys and UserLand Frontier, to function on an equal status with AppleScript. AppleScript was implemented as a scripting component, and the basic specs for interfacing such components to the OSA were public, allowing other developers to add their own scripting components to the system. Public client APIs for loading, saving and compiling scripts would work the same for all such components, which also meant that applets and droplets could hold scripts in any of those scripting languages.
Under Mac OS X, the JavaScript OSA component remains the only serious OSA language alternative to AppleScript, though the Macintosh versions of Perl, Python, Ruby, and Tcl all support native means of working with AppleEvents without being OSA components. The MacRuby development roadmap shows that OSA conformance is planned in version 0.6.[3]
One of the most interesting features of the OSA are "scripting additions", or OSAX for Open Scripting Architecture eXtension, which were based on Hypercard's External Commands. Scripting Additions allow programmers to extend the function of AppleScript. Commands included as Scripting Additions are available system wide, and are not dependent on an application. Mac OS X includes a collection of scripting additions referred to as Standard Additions, which extends the function of AppleScript with a variety of new commands, including user interaction dialogs, reading and writing files, file system commands, date functions, text and math operations.